// https://cdn.jsdelivr.net/npm/@floating-ui/core@1.7.0
!(function (t, e) {
  "object" == typeof exports && "undefined" != typeof module
    ? e(exports)
    : "function" == typeof define && define.amd
    ? define(["exports"], e)
    : e(
        ((t =
          "undefined" != typeof globalThis
            ? globalThis
            : t || self).FloatingUICore = {})
      );
})(this, function (t) {
  "use strict";
  const e = ["top", "right", "bottom", "left"],
    n = ["start", "end"],
    i = e.reduce((t, e) => t.concat(e, e + "-" + n[0], e + "-" + n[1]), []),
    o = Math.min,
    r = Math.max,
    a = { left: "right", right: "left", bottom: "top", top: "bottom" },
    l = { start: "end", end: "start" };
  function s(t, e, n) {
    return r(t, o(e, n));
  }
  function f(t, e) {
    return "function" == typeof t ? t(e) : t;
  }
  function c(t) {
    return t.split("-")[0];
  }
  function u(t) {
    return t.split("-")[1];
  }
  function m(t) {
    return "x" === t ? "y" : "x";
  }
  function d(t) {
    return "y" === t ? "height" : "width";
  }
  function g(t) {
    return ["top", "bottom"].includes(c(t)) ? "y" : "x";
  }
  function p(t) {
    return m(g(t));
  }
  function h(t, e, n) {
    void 0 === n && (n = !1);
    const i = u(t),
      o = p(t),
      r = d(o);
    let a =
      "x" === o
        ? i === (n ? "end" : "start")
          ? "right"
          : "left"
        : "start" === i
        ? "bottom"
        : "top";
    return e.reference[r] > e.floating[r] && (a = w(a)), [a, w(a)];
  }
  function y(t) {
    return t.replace(/start|end/g, (t) => l[t]);
  }
  function w(t) {
    return t.replace(/left|right|bottom|top/g, (t) => a[t]);
  }
  function x(t) {
    return "number" != typeof t
      ? (function (t) {
          return { top: 0, right: 0, bottom: 0, left: 0, ...t };
        })(t)
      : { top: t, right: t, bottom: t, left: t };
  }
  function v(t) {
    const { x: e, y: n, width: i, height: o } = t;
    return {
      width: i,
      height: o,
      top: n,
      left: e,
      right: e + i,
      bottom: n + o,
      x: e,
      y: n,
    };
  }
  function b(t, e, n) {
    let { reference: i, floating: o } = t;
    const r = g(e),
      a = p(e),
      l = d(a),
      s = c(e),
      f = "y" === r,
      m = i.x + i.width / 2 - o.width / 2,
      h = i.y + i.height / 2 - o.height / 2,
      y = i[l] / 2 - o[l] / 2;
    let w;
    switch (s) {
      case "top":
        w = { x: m, y: i.y - o.height };
        break;
      case "bottom":
        w = { x: m, y: i.y + i.height };
        break;
      case "right":
        w = { x: i.x + i.width, y: h };
        break;
      case "left":
        w = { x: i.x - o.width, y: h };
        break;
      default:
        w = { x: i.x, y: i.y };
    }
    switch (u(e)) {
      case "start":
        w[a] -= y * (n && f ? -1 : 1);
        break;
      case "end":
        w[a] += y * (n && f ? -1 : 1);
    }
    return w;
  }
  async function A(t, e) {
    var n;
    void 0 === e && (e = {});
    const { x: i, y: o, platform: r, rects: a, elements: l, strategy: s } = t,
      {
        boundary: c = "clippingAncestors",
        rootBoundary: u = "viewport",
        elementContext: m = "floating",
        altBoundary: d = !1,
        padding: g = 0,
      } = f(e, t),
      p = x(g),
      h = l[d ? ("floating" === m ? "reference" : "floating") : m],
      y = v(
        await r.getClippingRect({
          element:
            null ==
              (n = await (null == r.isElement ? void 0 : r.isElement(h))) || n
              ? h
              : h.contextElement ||
                (await (null == r.getDocumentElement
                  ? void 0
                  : r.getDocumentElement(l.floating))),
          boundary: c,
          rootBoundary: u,
          strategy: s,
        })
      ),
      w =
        "floating" === m
          ? { x: i, y: o, width: a.floating.width, height: a.floating.height }
          : a.reference,
      b = await (null == r.getOffsetParent
        ? void 0
        : r.getOffsetParent(l.floating)),
      A = ((await (null == r.isElement ? void 0 : r.isElement(b))) &&
        (await (null == r.getScale ? void 0 : r.getScale(b)))) || {
        x: 1,
        y: 1,
      },
      R = v(
        r.convertOffsetParentRelativeRectToViewportRelativeRect
          ? await r.convertOffsetParentRelativeRectToViewportRelativeRect({
              elements: l,
              rect: w,
              offsetParent: b,
              strategy: s,
            })
          : w
      );
    return {
      top: (y.top - R.top + p.top) / A.y,
      bottom: (R.bottom - y.bottom + p.bottom) / A.y,
      left: (y.left - R.left + p.left) / A.x,
      right: (R.right - y.right + p.right) / A.x,
    };
  }
  function R(t, e) {
    return {
      top: t.top - e.height,
      right: t.right - e.width,
      bottom: t.bottom - e.height,
      left: t.left - e.width,
    };
  }
  function P(t) {
    return e.some((e) => t[e] >= 0);
  }
  function D(t) {
    const e = o(...t.map((t) => t.left)),
      n = o(...t.map((t) => t.top));
    return {
      x: e,
      y: n,
      width: r(...t.map((t) => t.right)) - e,
      height: r(...t.map((t) => t.bottom)) - n,
    };
  }
  (t.arrow = (t) => ({
    name: "arrow",
    options: t,
    async fn(e) {
      const {
          x: n,
          y: i,
          placement: r,
          rects: a,
          platform: l,
          elements: c,
          middlewareData: m,
        } = e,
        { element: g, padding: h = 0 } = f(t, e) || {};
      if (null == g) return {};
      const y = x(h),
        w = { x: n, y: i },
        v = p(r),
        b = d(v),
        A = await l.getDimensions(g),
        R = "y" === v,
        P = R ? "top" : "left",
        D = R ? "bottom" : "right",
        T = R ? "clientHeight" : "clientWidth",
        O = a.reference[b] + a.reference[v] - w[v] - a.floating[b],
        E = w[v] - a.reference[v],
        L = await (null == l.getOffsetParent ? void 0 : l.getOffsetParent(g));
      let k = L ? L[T] : 0;
      (k && (await (null == l.isElement ? void 0 : l.isElement(L)))) ||
        (k = c.floating[T] || a.floating[b]);
      const C = O / 2 - E / 2,
        B = k / 2 - A[b] / 2 - 1,
        H = o(y[P], B),
        S = o(y[D], B),
        F = H,
        j = k - A[b] - S,
        z = k / 2 - A[b] / 2 + C,
        M = s(F, z, j),
        V =
          !m.arrow &&
          null != u(r) &&
          z !== M &&
          a.reference[b] / 2 - (z < F ? H : S) - A[b] / 2 < 0,
        W = V ? (z < F ? z - F : z - j) : 0;
      return {
        [v]: w[v] + W,
        data: {
          [v]: M,
          centerOffset: z - M - W,
          ...(V && { alignmentOffset: W }),
        },
        reset: V,
      };
    },
  })),
    (t.autoPlacement = function (t) {
      return (
        void 0 === t && (t = {}),
        {
          name: "autoPlacement",
          options: t,
          async fn(e) {
            var n, o, r;
            const {
                rects: a,
                middlewareData: l,
                placement: s,
                platform: m,
                elements: d,
              } = e,
              {
                crossAxis: g = !1,
                alignment: p,
                allowedPlacements: w = i,
                autoAlignment: x = !0,
                ...v
              } = f(t, e),
              b =
                void 0 !== p || w === i
                  ? (function (t, e, n) {
                      return (
                        t
                          ? [
                              ...n.filter((e) => u(e) === t),
                              ...n.filter((e) => u(e) !== t),
                            ]
                          : n.filter((t) => c(t) === t)
                      ).filter((n) => !t || u(n) === t || (!!e && y(n) !== n));
                    })(p || null, x, w)
                  : w,
              R = await A(e, v),
              P = (null == (n = l.autoPlacement) ? void 0 : n.index) || 0,
              D = b[P];
            if (null == D) return {};
            const T = h(
              D,
              a,
              await (null == m.isRTL ? void 0 : m.isRTL(d.floating))
            );
            if (s !== D) return { reset: { placement: b[0] } };
            const O = [R[c(D)], R[T[0]], R[T[1]]],
              E = [
                ...((null == (o = l.autoPlacement) ? void 0 : o.overflows) ||
                  []),
                { placement: D, overflows: O },
              ],
              L = b[P + 1];
            if (L)
              return {
                data: { index: P + 1, overflows: E },
                reset: { placement: L },
              };
            const k = E.map((t) => {
                const e = u(t.placement);
                return [
                  t.placement,
                  e && g
                    ? t.overflows.slice(0, 2).reduce((t, e) => t + e, 0)
                    : t.overflows[0],
                  t.overflows,
                ];
              }).sort((t, e) => t[1] - e[1]),
              C =
                (null ==
                (r = k.filter((t) =>
                  t[2].slice(0, u(t[0]) ? 2 : 3).every((t) => t <= 0)
                )[0])
                  ? void 0
                  : r[0]) || k[0][0];
            return C !== s
              ? {
                  data: { index: P + 1, overflows: E },
                  reset: { placement: C },
                }
              : {};
          },
        }
      );
    }),
    (t.computePosition = async (t, e, n) => {
      const {
          placement: i = "bottom",
          strategy: o = "absolute",
          middleware: r = [],
          platform: a,
        } = n,
        l = r.filter(Boolean),
        s = await (null == a.isRTL ? void 0 : a.isRTL(e));
      let f = await a.getElementRects({
          reference: t,
          floating: e,
          strategy: o,
        }),
        { x: c, y: u } = b(f, i, s),
        m = i,
        d = {},
        g = 0;
      for (let n = 0; n < l.length; n++) {
        const { name: r, fn: p } = l[n],
          {
            x: h,
            y: y,
            data: w,
            reset: x,
          } = await p({
            x: c,
            y: u,
            initialPlacement: i,
            placement: m,
            strategy: o,
            middlewareData: d,
            rects: f,
            platform: a,
            elements: { reference: t, floating: e },
          });
        (c = null != h ? h : c),
          (u = null != y ? y : u),
          (d = { ...d, [r]: { ...d[r], ...w } }),
          x &&
            g <= 50 &&
            (g++,
            "object" == typeof x &&
              (x.placement && (m = x.placement),
              x.rects &&
                (f =
                  !0 === x.rects
                    ? await a.getElementRects({
                        reference: t,
                        floating: e,
                        strategy: o,
                      })
                    : x.rects),
              ({ x: c, y: u } = b(f, m, s))),
            (n = -1));
      }
      return { x: c, y: u, placement: m, strategy: o, middlewareData: d };
    }),
    (t.detectOverflow = A),
    (t.flip = function (t) {
      return (
        void 0 === t && (t = {}),
        {
          name: "flip",
          options: t,
          async fn(e) {
            var n, i;
            const {
                placement: o,
                middlewareData: r,
                rects: a,
                initialPlacement: l,
                platform: s,
                elements: m,
              } = e,
              {
                mainAxis: d = !0,
                crossAxis: p = !0,
                fallbackPlacements: x,
                fallbackStrategy: v = "bestFit",
                fallbackAxisSideDirection: b = "none",
                flipAlignment: R = !0,
                ...P
              } = f(t, e);
            if (null != (n = r.arrow) && n.alignmentOffset) return {};
            const D = c(o),
              T = g(l),
              O = c(l) === l,
              E = await (null == s.isRTL ? void 0 : s.isRTL(m.floating)),
              L =
                x ||
                (O || !R
                  ? [w(l)]
                  : (function (t) {
                      const e = w(t);
                      return [y(t), e, y(e)];
                    })(l)),
              k = "none" !== b;
            !x &&
              k &&
              L.push(
                ...(function (t, e, n, i) {
                  const o = u(t);
                  let r = (function (t, e, n) {
                    const i = ["left", "right"],
                      o = ["right", "left"],
                      r = ["top", "bottom"],
                      a = ["bottom", "top"];
                    switch (t) {
                      case "top":
                      case "bottom":
                        return n ? (e ? o : i) : e ? i : o;
                      case "left":
                      case "right":
                        return e ? r : a;
                      default:
                        return [];
                    }
                  })(c(t), "start" === n, i);
                  return (
                    o &&
                      ((r = r.map((t) => t + "-" + o)),
                      e && (r = r.concat(r.map(y)))),
                    r
                  );
                })(l, R, b, E)
              );
            const C = [l, ...L],
              B = await A(e, P),
              H = [];
            let S = (null == (i = r.flip) ? void 0 : i.overflows) || [];
            if ((d && H.push(B[D]), p)) {
              const t = h(o, a, E);
              H.push(B[t[0]], B[t[1]]);
            }
            if (
              ((S = [...S, { placement: o, overflows: H }]),
              !H.every((t) => t <= 0))
            ) {
              var F, j;
              const t = ((null == (F = r.flip) ? void 0 : F.index) || 0) + 1,
                e = C[t];
              if (e) {
                var z;
                const n = "alignment" === p && T !== g(e),
                  i = (null == (z = S[0]) ? void 0 : z.overflows[0]) > 0;
                if (!n || i)
                  return {
                    data: { index: t, overflows: S },
                    reset: { placement: e },
                  };
              }
              let n =
                null ==
                (j = S.filter((t) => t.overflows[0] <= 0).sort(
                  (t, e) => t.overflows[1] - e.overflows[1]
                )[0])
                  ? void 0
                  : j.placement;
              if (!n)
                switch (v) {
                  case "bestFit": {
                    var M;
                    const t =
                      null ==
                      (M = S.filter((t) => {
                        if (k) {
                          const e = g(t.placement);
                          return e === T || "y" === e;
                        }
                        return !0;
                      })
                        .map((t) => [
                          t.placement,
                          t.overflows
                            .filter((t) => t > 0)
                            .reduce((t, e) => t + e, 0),
                        ])
                        .sort((t, e) => t[1] - e[1])[0])
                        ? void 0
                        : M[0];
                    t && (n = t);
                    break;
                  }
                  case "initialPlacement":
                    n = l;
                }
              if (o !== n) return { reset: { placement: n } };
            }
            return {};
          },
        }
      );
    }),
    (t.hide = function (t) {
      return (
        void 0 === t && (t = {}),
        {
          name: "hide",
          options: t,
          async fn(e) {
            const { rects: n } = e,
              { strategy: i = "referenceHidden", ...o } = f(t, e);
            switch (i) {
              case "referenceHidden": {
                const t = R(
                  await A(e, { ...o, elementContext: "reference" }),
                  n.reference
                );
                return {
                  data: { referenceHiddenOffsets: t, referenceHidden: P(t) },
                };
              }
              case "escaped": {
                const t = R(await A(e, { ...o, altBoundary: !0 }), n.floating);
                return { data: { escapedOffsets: t, escaped: P(t) } };
              }
              default:
                return {};
            }
          },
        }
      );
    }),
    (t.inline = function (t) {
      return (
        void 0 === t && (t = {}),
        {
          name: "inline",
          options: t,
          async fn(e) {
            const {
                placement: n,
                elements: i,
                rects: a,
                platform: l,
                strategy: s,
              } = e,
              { padding: u = 2, x: m, y: d } = f(t, e),
              p = Array.from(
                (await (null == l.getClientRects
                  ? void 0
                  : l.getClientRects(i.reference))) || []
              ),
              h = (function (t) {
                const e = t.slice().sort((t, e) => t.y - e.y),
                  n = [];
                let i = null;
                for (let t = 0; t < e.length; t++) {
                  const o = e[t];
                  !i || o.y - i.y > i.height / 2
                    ? n.push([o])
                    : n[n.length - 1].push(o),
                    (i = o);
                }
                return n.map((t) => v(D(t)));
              })(p),
              y = v(D(p)),
              w = x(u);
            const b = await l.getElementRects({
              reference: {
                getBoundingClientRect: function () {
                  if (
                    2 === h.length &&
                    h[0].left > h[1].right &&
                    null != m &&
                    null != d
                  )
                    return (
                      h.find(
                        (t) =>
                          m > t.left - w.left &&
                          m < t.right + w.right &&
                          d > t.top - w.top &&
                          d < t.bottom + w.bottom
                      ) || y
                    );
                  if (h.length >= 2) {
                    if ("y" === g(n)) {
                      const t = h[0],
                        e = h[h.length - 1],
                        i = "top" === c(n),
                        o = t.top,
                        r = e.bottom,
                        a = i ? t.left : e.left,
                        l = i ? t.right : e.right;
                      return {
                        top: o,
                        bottom: r,
                        left: a,
                        right: l,
                        width: l - a,
                        height: r - o,
                        x: a,
                        y: o,
                      };
                    }
                    const t = "left" === c(n),
                      e = r(...h.map((t) => t.right)),
                      i = o(...h.map((t) => t.left)),
                      a = h.filter((n) => (t ? n.left === i : n.right === e)),
                      l = a[0].top,
                      s = a[a.length - 1].bottom;
                    return {
                      top: l,
                      bottom: s,
                      left: i,
                      right: e,
                      width: e - i,
                      height: s - l,
                      x: i,
                      y: l,
                    };
                  }
                  return y;
                },
              },
              floating: i.floating,
              strategy: s,
            });
            return a.reference.x !== b.reference.x ||
              a.reference.y !== b.reference.y ||
              a.reference.width !== b.reference.width ||
              a.reference.height !== b.reference.height
              ? { reset: { rects: b } }
              : {};
          },
        }
      );
    }),
    (t.limitShift = function (t) {
      return (
        void 0 === t && (t = {}),
        {
          options: t,
          fn(e) {
            const { x: n, y: i, placement: o, rects: r, middlewareData: a } = e,
              { offset: l = 0, mainAxis: s = !0, crossAxis: u = !0 } = f(t, e),
              d = { x: n, y: i },
              p = g(o),
              h = m(p);
            let y = d[h],
              w = d[p];
            const x = f(l, e),
              v =
                "number" == typeof x
                  ? { mainAxis: x, crossAxis: 0 }
                  : { mainAxis: 0, crossAxis: 0, ...x };
            if (s) {
              const t = "y" === h ? "height" : "width",
                e = r.reference[h] - r.floating[t] + v.mainAxis,
                n = r.reference[h] + r.reference[t] - v.mainAxis;
              y < e ? (y = e) : y > n && (y = n);
            }
            if (u) {
              var b, A;
              const t = "y" === h ? "width" : "height",
                e = ["top", "left"].includes(c(o)),
                n =
                  r.reference[p] -
                  r.floating[t] +
                  ((e && (null == (b = a.offset) ? void 0 : b[p])) || 0) +
                  (e ? 0 : v.crossAxis),
                i =
                  r.reference[p] +
                  r.reference[t] +
                  (e ? 0 : (null == (A = a.offset) ? void 0 : A[p]) || 0) -
                  (e ? v.crossAxis : 0);
              w < n ? (w = n) : w > i && (w = i);
            }
            return { [h]: y, [p]: w };
          },
        }
      );
    }),
    (t.offset = function (t) {
      return (
        void 0 === t && (t = 0),
        {
          name: "offset",
          options: t,
          async fn(e) {
            var n, i;
            const { x: o, y: r, placement: a, middlewareData: l } = e,
              s = await (async function (t, e) {
                const { placement: n, platform: i, elements: o } = t,
                  r = await (null == i.isRTL ? void 0 : i.isRTL(o.floating)),
                  a = c(n),
                  l = u(n),
                  s = "y" === g(n),
                  m = ["left", "top"].includes(a) ? -1 : 1,
                  d = r && s ? -1 : 1,
                  p = f(e, t);
                let {
                  mainAxis: h,
                  crossAxis: y,
                  alignmentAxis: w,
                } = "number" == typeof p
                  ? { mainAxis: p, crossAxis: 0, alignmentAxis: null }
                  : {
                      mainAxis: p.mainAxis || 0,
                      crossAxis: p.crossAxis || 0,
                      alignmentAxis: p.alignmentAxis,
                    };
                return (
                  l && "number" == typeof w && (y = "end" === l ? -1 * w : w),
                  s ? { x: y * d, y: h * m } : { x: h * m, y: y * d }
                );
              })(e, t);
            return a === (null == (n = l.offset) ? void 0 : n.placement) &&
              null != (i = l.arrow) &&
              i.alignmentOffset
              ? {}
              : { x: o + s.x, y: r + s.y, data: { ...s, placement: a } };
          },
        }
      );
    }),
    (t.rectToClientRect = v),
    (t.shift = function (t) {
      return (
        void 0 === t && (t = {}),
        {
          name: "shift",
          options: t,
          async fn(e) {
            const { x: n, y: i, placement: o } = e,
              {
                mainAxis: r = !0,
                crossAxis: a = !1,
                limiter: l = {
                  fn: (t) => {
                    let { x: e, y: n } = t;
                    return { x: e, y: n };
                  },
                },
                ...u
              } = f(t, e),
              d = { x: n, y: i },
              p = await A(e, u),
              h = g(c(o)),
              y = m(h);
            let w = d[y],
              x = d[h];
            if (r) {
              const t = "y" === y ? "bottom" : "right";
              w = s(w + p["y" === y ? "top" : "left"], w, w - p[t]);
            }
            if (a) {
              const t = "y" === h ? "bottom" : "right";
              x = s(x + p["y" === h ? "top" : "left"], x, x - p[t]);
            }
            const v = l.fn({ ...e, [y]: w, [h]: x });
            return {
              ...v,
              data: { x: v.x - n, y: v.y - i, enabled: { [y]: r, [h]: a } },
            };
          },
        }
      );
    }),
    (t.size = function (t) {
      return (
        void 0 === t && (t = {}),
        {
          name: "size",
          options: t,
          async fn(e) {
            var n, i;
            const { placement: a, rects: l, platform: s, elements: m } = e,
              { apply: d = () => {}, ...p } = f(t, e),
              h = await A(e, p),
              y = c(a),
              w = u(a),
              x = "y" === g(a),
              { width: v, height: b } = l.floating;
            let R, P;
            "top" === y || "bottom" === y
              ? ((R = y),
                (P =
                  w ===
                  ((await (null == s.isRTL ? void 0 : s.isRTL(m.floating)))
                    ? "start"
                    : "end")
                    ? "left"
                    : "right"))
              : ((P = y), (R = "end" === w ? "top" : "bottom"));
            const D = b - h.top - h.bottom,
              T = v - h.left - h.right,
              O = o(b - h[R], D),
              E = o(v - h[P], T),
              L = !e.middlewareData.shift;
            let k = O,
              C = E;
            if (
              (null != (n = e.middlewareData.shift) && n.enabled.x && (C = T),
              null != (i = e.middlewareData.shift) && i.enabled.y && (k = D),
              L && !w)
            ) {
              const t = r(h.left, 0),
                e = r(h.right, 0),
                n = r(h.top, 0),
                i = r(h.bottom, 0);
              x
                ? (C =
                    v - 2 * (0 !== t || 0 !== e ? t + e : r(h.left, h.right)))
                : (k =
                    b - 2 * (0 !== n || 0 !== i ? n + i : r(h.top, h.bottom)));
            }
            await d({ ...e, availableWidth: C, availableHeight: k });
            const B = await s.getDimensions(m.floating);
            return v !== B.width || b !== B.height
              ? { reset: { rects: !0 } }
              : {};
          },
        }
      );
    });
});
